การประเมิน Machine Learning ด้วย Python: Metrics เทียบกับ Scoring – คู่มือระดับโลก

ในโลกของ Machine Learning (ML) ที่กว้างใหญ่และพัฒนาอย่างรวดเร็ว การสร้างโมเดลเป็นเพียงครึ่งทาง อีกครึ่งหนึ่งที่สำคัญกว่านั้นคือ การประเมิน ประสิทธิภาพของมัน โมเดลไม่ว่าจะซับซ้อนเพียงใด จะดีเท่ากับความสามารถในการแก้ปัญหาที่มันถูกออกแบบมาเท่านั้น แต่เราจะวัด "ความดี" ได้อย่างไรจริงๆ? คำถามนี้นำเราไปสู่แนวคิดหลักของการประเมิน: Metrics และ Scoring

สำหรับนักวิทยาศาสตร์ข้อมูลและวิศวกร ML ที่ทำงานในบริบททั่วโลก การทำความเข้าใจแนวคิดเหล่านี้อย่างลึกซึ้งใน Python ไม่ใช่แค่เรื่องความเชี่ยวชาญทางเทคนิคเท่านั้น แต่เป็นการสร้างความมั่นใจในความเป็นธรรม ความน่าเชื่อถือ และผลกระทบในโลกแห่งความเป็นจริงในชุดข้อมูลและกลุ่มผู้ใช้ที่หลากหลาย คู่มือที่ครอบคลุมนี้จะช่วยไขข้อข้องใจเกี่ยวกับการประเมิน ML ด้วย Python โดยแยกความแตกต่างระหว่าง metrics และ scoring อย่างชัดเจน สำรวจเทคนิคที่สำคัญ และให้ข้อมูลเชิงลึกที่นำไปปฏิบัติได้จริงสำหรับการประเมินโมเดลที่แข็งแกร่ง

บทบาทที่ขาดไม่ได้ของการประเมินใน Machine Learning

ลองนึกภาพการนำโมเดล ML ไปใช้งานเพื่อทำนายความน่าเชื่อถือทางเครดิตหรือวินิจฉัยภาวะทางการแพทย์ที่สำคัญ หากประสิทธิภาพไม่ได้รับการประเมินอย่างเข้มงวด ผลที่ตามมาอาจมีตั้งแต่การสูญเสียทางการเงินไปจนถึงความขัดแย้งทางจริยธรรมที่ร้ายแรง หรือแม้กระทั่งข้อผิดพลาดที่คุกคามชีวิต การประเมินไม่ใช่เพียงขั้นตอนสุดท้าย แต่เป็นกระบวนการที่ทำซ้ำๆ ซึ่งนำทางการพัฒนาโมเดลตั้งแต่แนวคิดไปจนถึงการนำไปใช้และการบำรุงรักษาอย่างต่อเนื่อง

การประเมินที่มีประสิทธิภาพช่วยให้เรา:

• ตรวจสอบประสิทธิภาพของโมเดล: ยืนยันว่าโมเดลสามารถทำงานได้ดีกับข้อมูลที่ไม่เคยเห็นมาก่อน ไม่ใช่แค่ชุดข้อมูลฝึกฝน
• เปรียบเทียบโมเดล: กำหนดว่าโมเดลหรืออัลกอริทึมใดเหมาะสมที่สุดสำหรับปัญหาเฉพาะ
• ปรับแต่ง Hyperparameters: ปรับการตั้งค่าโมเดลเพื่อให้ได้ประสิทธิภาพสูงสุด
• ระบุปัญหาเรื่องความลำเอียงและความเป็นธรรม: สิ่งสำคัญอย่างยิ่งสำหรับการใช้งานทั่วโลก เพื่อให้แน่ใจว่าโมเดลทำงานได้ดีเท่าเทียมกันในกลุ่มประชากร กลุ่มภูมิภาค หรือบริบททางวัฒนธรรมที่แตกต่างกัน
• สื่อสารผลลัพธ์แก่ผู้มีส่วนได้ส่วนเสีย: แปลงประสิทธิภาพโมเดลที่ซับซ้อนให้เป็นผลลัพธ์ทางธุรกิจที่เข้าใจได้
• แจ้งการตัดสินใจทางธุรกิจ: ตรวจสอบให้แน่ใจว่าข้อมูลเชิงลึกที่ได้จากโมเดลนั้นน่าเชื่อถือและนำไปปฏิบัติได้จริง

หากไม่มีกรอบการประเมินที่แข็งแกร่ง แม้แต่นวัตกรรมโซลูชัน ML ที่ล้ำสมัยที่สุดก็อาจเสี่ยงต่อการไม่น่าเชื่อถือ ไม่ยุติธรรม หรือไม่เกี่ยวข้องในสถานการณ์จริง

ทำความเข้าใจแนวคิดหลัก: Metrics เทียบกับ Scoring

แม้ว่ามักจะใช้สลับกัน แต่ "metrics" และ "scoring" ในบริบทของระบบนิเวศ Machine Learning ของ Python โดยเฉพาะอย่างยิ่งกับไลบรารีอย่าง Scikit-learn หมายถึงแนวคิดที่แตกต่างแต่เกี่ยวข้องกัน การทำความเข้าใจความแตกต่างนี้เป็นพื้นฐานสำหรับการประเมินโมเดลที่มีประสิทธิภาพ

Metrics คืออะไร?

Metrics คือการวัดเชิงปริมาณที่ใช้ในการประเมินประสิทธิภาพของโมเดล Machine Learning พวกมันคือการคำนวณที่แท้จริงที่บอกเราว่าโมเดลของเราทำงานได้ดีเพียงใดในแง่มุมเฉพาะของงาน ลองนึกถึงสิ่งเหล่านี้เหมือนกับ "รายการในสมุดคะแนน" เอง

ตัวอย่าง metrics ที่พบบ่อย ได้แก่:

• Accuracy: สัดส่วนของอินสแตนซ์ที่ทำนายถูกต้อง
• Precision: สัดส่วนของการระบุว่าเป็นบวกที่ถูกต้องจริงๆ
• Mean Absolute Error (MAE): ค่าเฉลี่ยของผลต่างสัมบูรณ์ระหว่างการทำนายและค่าจริง
• R-squared (R²): สัดส่วนของความแปรปรวนในตัวแปรตามที่สามารถทำนายได้จากตัวแปรอิสระ

โดยทั่วไป Metrics จะถูกคำนวณโดยตรงจากการทำนายของโมเดลและป้ายกำกับ/ค่าจริง คุณคำนวณสิ่งเหล่านี้หลังจากที่โมเดลได้ทำการทำนายบนชุดข้อมูลแล้ว

Scoring คืออะไร?

Scoring ในบริบทของ Scikit-learn หมายถึง ฟังก์ชัน หรือ กระบวนการ ที่ใช้ metric (หรือชุดของ metrics) ในการประเมินโมเดล บ่อยครั้งที่เกี่ยวข้องกับวิธีที่เป็นมาตรฐานในการส่งข้อมูลไปยังโมเดล แล้วใช้ metric ที่เลือกกับผลลัพธ์ ฟังก์ชัน Scoring มักใช้ภายในโดย Scikit-learn estimators และ utilities สำหรับงานต่างๆ เช่น cross-validation, hyperparameter tuning หรือ model selection

คุณลักษณะสำคัญของฟังก์ชัน Scoring:

• บ่อยครั้งที่ส่งคืนค่าตัวเลขเดียว ทำให้เหมาะสำหรับการปรับให้เหมาะสม (เช่น การหา hyperparameter ที่เพิ่มคะแนนสูงสุด)
• Scikit-learn estimators มักจะมีเมธอด score() เริ่มต้นที่ใช้ metric ที่กำหนดไว้ล่วงหน้า (เช่น accuracy สำหรับ classifiers, R² สำหรับ regressors)
• Utilities เช่น cross_val_score หรือ GridSearchCV ยอมรับพารามิเตอร์ scoring ซึ่งสามารถเป็นสตริง (อ้างอิงถึง metric ที่กำหนดไว้ล่วงหน้า) หรือ callable object (ฟังก์ชัน scoring ที่กำหนดเอง)

ดังนั้น ในขณะที่ metric คือการคำนวณขั้นสุดท้าย scorer คือกลไกหรือ wrapper ที่อำนวยความสะดวกในการใช้ metric นั้นอย่างสม่ำเสมอ โดยเฉพาะอย่างยิ่งภายในไปป์ไลน์การประเมินอัตโนมัติ

ความแตกต่างที่สำคัญ

สรุป:

• Metric คือสูตรหรือการคำนวณ (เช่น "คำนวณ accuracy")
• Scorer คือฟังก์ชันหรือเมธอดที่ ใช้ metric เพื่อสร้างค่าประสิทธิภาพ บ่อยครั้งในวิธีที่เป็นมาตรฐานสำหรับงานฝึกโมเดลและเลือกโมเดล (เช่น model.score(X_test, y_test) หรือ cross_val_score(model, X, y, scoring='f1_macro'))

การทำความเข้าใจสิ่งนี้หมายความว่าคุณเลือก metric ที่ถูกต้องเพื่อทำความเข้าใจประสิทธิภาพของโมเดลของคุณในปัญหาเฉพาะ และคุณใช้ ฟังก์ชัน scoring ที่เหมาะสมเมื่อคุณต้องการทำให้การประเมินนั้นเป็นอัตโนมัติ โดยเฉพาะอย่างยิ่งในระหว่างการฝึกโมเดล การเลือกโมเดล หรือการปรับ hyperparameter ให้เหมาะสม

Metrics การประเมินที่สำคัญใน ML ของ Python

ระบบนิเวศที่หลากหลายของ Python โดยเฉพาะ Scikit-learn มีชุด metrics ที่ครอบคลุมสำหรับงาน ML ต่างๆ การเลือก metric ที่ถูกต้องขึ้นอยู่กับประเภทของปัญหา ลักษณะของข้อมูลของคุณ และวัตถุประสงค์ทางธุรกิจ

Classification Metrics

โมเดล Classification ทำนายผลลัพธ์แบบหมวดหมู่ การประเมินผลต้องพิจารณาอย่างรอบคอบ โดยเฉพาะอย่างยิ่งกับชุดข้อมูลที่ไม่สมดุล

• Accuracy Score:
  • Description: อัตราส่วนของการสังเกตการณ์ที่ทำนายถูกต้องต่อการสังเกตการณ์ทั้งหมด
  • Formula: (True Positives + True Negatives) / Total Observations
  • When to Use: ส่วนใหญ่เมื่อคลาสมีความสมดุลดี
  • Caveats: อาจทำให้เข้าใจผิดได้สำหรับชุดข้อมูลที่ไม่สมดุล ตัวอย่างเช่น โมเดลที่ทำนาย "ไม่มีโรค" 95% ของเวลาในชุดข้อมูลที่มีผู้ป่วยเพียง 5% จะมี accuracy 95% แต่โมเดลนั้นล้มเหลวในการระบุผู้ป่วยที่ติดเชื้อเลย
• Confusion Matrix:
  • Description: ตารางที่อธิบายประสิทธิภาพของโมเดล Classification บนชุดข้อมูลทดสอบที่ทราบค่าจริง ซึ่งจะแบ่งการทำนายออกเป็น True Positives (TP), True Negatives (TN), False Positives (FP), และ False Negatives (FN)
  • When to Use: เสมอ! เป็นส่วนประกอบพื้นฐานสำหรับ metrics อื่นๆ อีกมากมาย และให้ภาพที่ชัดเจนของข้อผิดพลาดในการทำนาย
• Precision, Recall, และ F1-Score:
  • Description: ได้มาจาก Confusion Matrix
    • Precision: (TP / (TP + FP)) – จากการทำนายว่าเป็นบวกทั้งหมด มีกี่รายการที่ถูกต้องจริงๆ? มีประโยชน์เมื่อค่าใช้จ่ายของ False Positive สูง (เช่น การตรวจจับสแปม)
    • Recall (Sensitivity): (TP / (TP + FN)) – จากจำนวนบวกทั้งหมด มีกี่รายการที่เราสามารถระบุได้อย่างถูกต้อง? มีประโยชน์เมื่อค่าใช้จ่ายของ False Negative สูง (เช่น การวินิจฉัยโรค)
    • F1-Score: (2 * Precision * Recall) / (Precision + Recall) – ค่าเฉลี่ยฮาร์มอนิกของ Precision และ Recall มีประโยชน์เมื่อคุณต้องการความสมดุลระหว่าง Precision และ Recall โดยเฉพาะอย่างยิ่งกับการกระจายคลาสที่ไม่เท่ากัน
  • When to Use: จำเป็นสำหรับชุดข้อมูลที่ไม่สมดุลหรือเมื่อข้อผิดพลาดประเภทต่างๆ มีค่าใช้จ่ายแตกต่างกัน
  • Scikit-learn: sklearn.metrics.precision_score, recall_score, f1_score, และ classification_report (ซึ่งให้ทั้งสามค่า บวก accuracy และ support สำหรับแต่ละคลาส)
• ROC AUC Score (Receiver Operating Characteristic - Area Under the Curve):
  • Description: พล็อต True Positive Rate (TPR/Recall) กับ False Positive Rate (FPR) ที่การตั้งค่า threshold ต่างๆ AUC แสดงถึงระดับหรือมาตรวัดของการแยกคลาสต่างๆ ค่า AUC ที่สูงขึ้นหมายความว่าโมเดลสามารถแยกความแตกต่างระหว่างคลาสบวกและลบได้ดีขึ้น
  • When to Use: สำหรับปัญหา binary classification โดยเฉพาะอย่างยิ่งกับคลาสที่ไม่สมดุล เนื่องจากให้มาตรวัดแบบรวมที่ครอบคลุมทุก threshold การจำแนกที่เป็นไปได้ มีประโยชน์เมื่อคุณต้องการทำความเข้าใจว่าโมเดลสามารถจัดอันดับอินสแตนซ์บวกสูงกว่าอินสแตนซ์ลบได้ดีเพียงใด
  • Caveats: มีความเข้าใจยากกว่าสำหรับปัญหา multi-class (แม้ว่าจะมีส่วนขยาย) และไม่ได้บอก threshold ที่เหมาะสมที่สุด
• Log Loss (Logistic Loss / Cross-Entropy Loss):
  • Description: วัดประสิทธิภาพของโมเดล Classification ที่อินพุตการทำนายเป็นค่าความน่าจะเป็นระหว่าง 0 ถึง 1 มันจะลงโทษการจำแนกประเภทที่ไม่ถูกต้องที่ทำด้วยความมั่นใจสูง
  • When to Use: เมื่อคุณต้องการความน่าจะเป็นที่ปรับเทียบอย่างดี ไม่ใช่แค่ป้ายกำกับคลาสที่ถูกต้อง มีประโยชน์สำหรับ multi-class classification และโมเดลที่ส่งออกความน่าจะเป็น
  • Caveats: ซับซ้อนกว่าในการตีความมากกว่า accuracy และมีความไวต่อค่าผิดปกติและการทำนายผิดด้วยความมั่นใจสูง
• Jaccard Index (Intersection over Union):
  • Description: วัดความคล้ายคลึงกันระหว่างชุดตัวอย่างจำกัดสองชุด สำหรับ Classification จะกำหนดเป็นขนาดของ intersection หารด้วยขนาดของ union ของชุดป้ายกำกับที่ทำนายและป้ายกำกับจริง
  • When to Use: พบได้บ่อยเป็นพิเศษในการแบ่งส่วนภาพ (image segmentation) (เปรียบเทียบ predicted masks กับ ground truth) หรือเมื่อประเมิน multi-label classification ซึ่งแต่ละอินสแตนซ์สามารถเป็นได้หลายประเภท
• Kappa Score (Cohen's Kappa):
  • Description: วัดความสอดคล้องระหว่างผู้ประเมินสองคน หรือใน ML ระหว่างการทำนายของโมเดลกับป้ายกำกับจริง โดยคำนึงถึงความเป็นไปได้ที่จะเกิดความสอดคล้องโดยบังเอิญ
  • When to Use: มีประโยชน์สำหรับปัญหา multi-class โดยเฉพาะอย่างยิ่งกับชุดข้อมูลที่ไม่สมดุล ซึ่ง accuracy อาจทำให้เข้าใจผิด ค่าจะอยู่ในช่วงตั้งแต่ -1 (ไม่มีความสอดคล้องเลย) ถึง 1 (สอดคล้องกันอย่างสมบูรณ์) โดย 0 บ่งชี้ถึงความสอดคล้องโดยบังเอิญ

Regression Metrics

โมเดล Regression ทำนายค่าตัวเลขต่อเนื่อง การประเมินผลจะมุ่งเน้นไปที่ขนาดของข้อผิดพลาดในการทำนาย

• Mean Absolute Error (MAE):
  • Description: ค่าเฉลี่ยของผลต่างสัมบูรณ์ระหว่างค่าที่ทำนายและค่าจริง ข้อผิดพลาดแต่ละรายการจะถูกถ่วงน้ำหนักเท่ากัน
  • Formula: (1/n) * Σ|y_true - y_pred|
  • When to Use: เมื่อคุณต้องการให้ข้อผิดพลาดถูกตีความในหน่วยเดียวกับตัวแปรเป้าหมาย และเมื่อคุณต้องการ metric ที่ทนทานต่อค่าผิดปกติ (เช่น ไม่ไวต่อข้อผิดพลาดขนาดใหญ่)
• Mean Squared Error (MSE) / Root Mean Squared Error (RMSE):
  • Description:
    • MSE: ค่าเฉลี่ยของผลต่างกำลังสองระหว่างค่าที่ทำนายและค่าจริง ลงโทษข้อผิดพลาดที่ใหญ่กว่าอย่างหนักกว่าข้อผิดพลาดที่เล็กกว่า
    • RMSE: รากที่สองของ MSE แปลงข้อผิดพลาดกลับไปเป็นหน่วยเดิมของตัวแปรเป้าหมาย ทำให้ตีความได้มากกว่า MSE
  • Formula:
    • MSE: (1/n) * Σ(y_true - y_pred)²
    • RMSE: √(MSE)
  • When to Use: เมื่อข้อผิดพลาดที่ใหญ่กว่าไม่เป็นที่ต้องการอย่างมาก มักใช้เมื่อคาดว่าข้อผิดพลาดจะมีการกระจายแบบปกติ
• R-squared (R²) / Coefficient of Determination:
  • Description: แสดงสัดส่วนของความแปรปรวนในตัวแปรตามที่สามารถทำนายได้จากตัวแปรอิสระ มีค่าตั้งแต่ 0 ถึง 1 โดย 1 บ่งชี้ว่าโมเดลอธิบายความแปรปรวนทั้งหมดของข้อมูลการตอบสนองรอบๆ ค่าเฉลี่ยได้
  • Formula: 1 - (SSR / SST) โดยที่ SSR คือผลรวมของกำลังสองของส่วนที่เหลือ (sum of squared residuals) และ SST คือผลรวมกำลังสองทั้งหมด (total sum of squares)
  • When to Use: เพื่อทำความเข้าใจว่าโมเดลของคุณสามารถอธิบายความแปรปรวนในตัวแปรเป้าหมายของคุณได้มากน้อยเพียงใด เหมาะสำหรับการประเมินความเหมาะสมของโมเดลโดยรวม
  • Caveats: อาจทำให้เข้าใจผิดได้หากคุณเพิ่มตัวแปรอิสระมากขึ้น (ค่า R² จะเพิ่มขึ้นหรือคงที่เสมอ) ใช้ Adjusted R² สำหรับการเปรียบเทียบโมเดลที่มีจำนวนตัวทำนายต่างกัน
• Median Absolute Error:
  • Description: ค่ามัธยฐานของผลต่างสัมบูรณ์ทั้งหมดระหว่างการทำนายและค่าจริง
  • When to Use: คล้ายกับ MAE มีความทนทานต่อค่าผิดปกติสูงยิ่งกว่า MAE เสียอีก เนื่องจากค่ามัธยฐานได้รับผลกระทบจากค่าที่สูงมากน้อยกว่า

Clustering Metrics

อัลกอริทึม Clustering จัดกลุ่มจุดข้อมูลที่คล้ายกันเข้าด้วยกัน การประเมินผลอาจเป็นเรื่องท้าทาย เนื่องจากบ่อยครั้งที่ไม่มี "ground truth" ให้เปรียบเทียบ Metric มักจะเป็น intrinsic (อาศัยเฉพาะข้อมูลและการกำหนดคลัสเตอร์)

• Silhouette Score:
  • Description: วัดว่าวัตถุมีความคล้ายคลึงกับคลัสเตอร์ของตนเอง (cohesion) เมื่อเทียบกับคลัสเตอร์อื่น (separation) มากน้อยเพียงใด มีค่าตั้งแต่ -1 ถึง 1 ค่าสูงบ่งชี้ว่าวัตถุตรงกับคลัสเตอร์ของตนเองได้ดีและตรงกับคลัสเตอร์ข้างเคียงได้ไม่ดี
  • When to Use: เพื่อประเมินคุณภาพของคลัสเตอร์เมื่อไม่มี ground truth labels มีประโยชน์ในการกำหนดจำนวนคลัสเตอร์ที่เหมาะสมที่สุด
  • Caveats: อาจใช้ทรัพยากรมากในการคำนวณสำหรับชุดข้อมูลขนาดใหญ่ สมมติว่าคลัสเตอร์มีลักษณะเป็นทรงกลม (convex)
• Davies-Bouldin Index:
  • Description: อัตราส่วนของระยะห่างภายในคลัสเตอร์ต่อระยะห่างระหว่างคลัสเตอร์ ค่าที่ต่ำกว่าบ่งชี้ถึงการจัดกลุ่มที่ดีกว่า (คลัสเตอร์มีความกะทัดรัดและอยู่ห่างกันมากขึ้น)
  • When to Use: เพื่อระบุจำนวนคลัสเตอร์ที่เหมาะสมที่สุด
  • Caveats: อาจมีความลำเอียงต่อคลัสเตอร์ที่มีลักษณะทรงกลม
• Calinski-Harabasz Index (Variance Ratio Criterion):
  • Description: อัตราส่วนของผลรวมของการกระจายระหว่างคลัสเตอร์และการกระจายภายในคลัสเตอร์ ค่าที่สูงกว่าสอดคล้องกับโมเดลที่มีคลัสเตอร์ที่กำหนดได้ดีกว่า
  • When to Use: คล้ายกับ Silhouette และ Davies-Bouldin สำหรับการกำหนดจำนวนคลัสเตอร์ที่เหมาะสมที่สุด

Ranking and Recommendation Metrics

สำหรับระบบที่ลำดับของการทำนายมีความสำคัญ เช่น ผลการค้นหา หรือคำแนะนำผลิตภัณฑ์

• Precision@k และ Recall@k:
  • Description: วัด precision หรือ recall สำหรับรายการ 'k' อันดับแรกที่แนะนำหรือดึงมา
  • When to Use: เมื่อผู้ใช้มักจะโต้ตอบเฉพาะกับคำแนะนำไม่กี่รายการแรก
• NDCG (Normalized Discounted Cumulative Gain):
  • Description: วัดประโยชน์หรือ gain ของเอกสารตามตำแหน่งในรายการผลลัพธ์ Gain จะสะสมจากด้านบนของรายการผลลัพธ์ไปยังด้านล่าง โดย gain ของแต่ละผลลัพธ์จะลดลงที่อันดับที่ต่ำกว่า
  • When to Use: สำหรับการประเมินเครื่องมือค้นหาหรือระบบแนะนำผลิตภัณฑ์ ซึ่งรายการต่างๆ มีระดับความเกี่ยวข้องที่แตกต่างกันและตำแหน่งมีความสำคัญ
• MAP (Mean Average Precision):
  • Description: ค่าเฉลี่ยของคะแนน Average Precision (AP) สำหรับแต่ละ query AP คือค่าเฉลี่ยของค่า precision ที่รายการที่เกี่ยวข้องแต่ละรายการในรายการที่จัดอันดับ
  • When to Use: Metric ตัวเลขเดียวที่จับลักษณะ precision และ recall ของรายการที่จัดอันดับได้ดี สำหรับการประเมินระบบการดึงข้อมูล

ฟังก์ชัน Scoring ใน Scikit-learn ของ Python

Scikit-learn มี API ที่เป็นหนึ่งเดียวสำหรับการฝึกและการประเมินโมเดล ทำให้มีประสิทธิภาพอย่างยิ่งสำหรับการทำให้เวิร์กโฟลว์ ML เป็นอัตโนมัติ แนวคิดของ "scoring" เป็นส่วนสำคัญของ API นี้ โดยเฉพาะอย่างยิ่งสำหรับงานที่เกี่ยวข้องกับ cross-validation และ hyperparameter optimization

เมธอด score()

Estimators (โมเดล) ส่วนใหญ่ของ Scikit-learn มาพร้อมกับเมธอด score(X, y) เริ่มต้น เมธอดนี้คำนวณ metric ประสิทธิภาพที่กำหนดไว้ล่วงหน้าสำหรับประเภทโมเดลนั้นๆ ภายใน

• สำหรับ classifiers (เช่น LogisticRegression, RandomForestClassifier) score() มักจะส่งคืน accuracy score
• สำหรับ regressors (เช่น LinearRegression, SVR) score() มักจะส่งคืน R-squared (R²) score

แม้จะสะดวก แต่การพึ่งพา score() เริ่มต้นเพียงอย่างเดียวนั้นมีข้อจำกัด โดยเฉพาะอย่างยิ่งสำหรับการจำแนกประเภทที่ไม่สมดุล หรือเมื่อต้องการ metric หลักที่แตกต่างกันสำหรับวัตถุประสงค์ทางธุรกิจของคุณ

cross_val_score() และ cross_validate()

ฟังก์ชันเหล่านี้จำเป็นสำหรับการประเมินโมเดลที่แข็งแกร่ง โดยให้การประมาณประสิทธิภาพของโมเดลที่น่าเชื่อถือกว่าการแบ่ง train-test เพียงครั้งเดียว พวกมันฝึกฝนและทดสอบโมเดลซ้ำๆ ในชุดข้อมูลย่อยต่างๆ

• cross_val_score(estimator, X, y, scoring=None, cv=None):
  • ดำเนินการ cross-validation และส่งคืน array ของคะแนน โดยมีคะแนนสำหรับแต่ละ fold
  • พารามิเตอร์ scoring คือที่ที่แนวคิดของ "scorer" เข้ามามีบทบาท คุณสามารถส่งสตริง (เช่น 'accuracy', 'f1_macro', 'neg_mean_squared_error') หรือ scorer object ที่ callable Scikit-learn จะเก็บ รายการของ scoring strings ที่กำหนดไว้ล่วงหน้า
  • สำหรับ regression metric เช่น MSE มักจะเป็น ข้อผิดพลาด โดยค่าที่ต่ำกว่าจะดีกว่า ฟังก์ชัน scoring ของ Scikit-learn มักคาดหวัง metric ที่ "สูงกว่าจะดี" ดังนั้น metric ที่เป็นข้อผิดพลาดจึงถูกนำหน้าด้วย 'neg_' (เช่น 'neg_mean_squared_error') เพื่อให้ได้ค่าสูงสุด
• cross_validate(estimator, X, y, scoring=None, cv=None, return_train_score=False):
  • เวอร์ชันที่ครอบคลุมกว่าที่สามารถส่งคืนคะแนนหลายรายการ (คะแนน train และ test สำหรับ metrics ต่างๆ), fit times, และ score times
  • พารามิเตอร์ scoring สามารถรับรายการหรือ dict ของ scoring strings เพื่อประเมินโมเดลโดยใช้หลาย metrics พร้อมกัน นี่มีประโยชน์อย่างยิ่งในการรับมุมมองแบบองค์รวมของประสิทธิภาพในแง่มุมต่างๆ

Custom Scoring Functions ด้วย make_scorer

จะเกิดอะไรขึ้นหาก metric การประเมินที่คุณต้องการไม่มีให้ใช้งานโดยตรงเป็น scoring string ใน Scikit-learn? หรือจะเกิดอะไรขึ้นหากคุณต้องการส่งพารามิเตอร์เฉพาะไปยังฟังก์ชัน metric (เช่น กลยุทธ์การเฉลี่ยสำหรับ F1-score)?

ฟังก์ชัน sklearn.metrics.make_scorer ของ Scikit-learn ช่วยให้คุณสามารถสร้าง scorer objects แบบกำหนดเองจากฟังก์ชัน metric ใดก็ได้ นี่มีประสิทธิภาพอย่างยิ่งสำหรับการปรับแต่งการประเมินให้ตรงกับความต้องการทางธุรกิจที่แม่นยำ

เมื่อสร้าง custom scorer คุณมักจะส่ง:

• ฟังก์ชัน metric (เช่น f1_score, accuracy_score)
• greater_is_better=True (ค่าเริ่มต้น) หรือ False ขึ้นอยู่กับว่าค่าที่สูงกว่าของ metric นั้นดีกว่า (เช่น accuracy) หรือแย่กว่า (เช่น MAE)
• พารามิเตอร์เพิ่มเติมสำหรับฟังก์ชัน metric (เช่น average='weighted' สำหรับ f1_score)
• needs_proba=True หรือ needs_threshold=True หากฟังก์ชัน metric ของคุณต้องการการประมาณความน่าจะเป็น (probability estimates) หรือผลลัพธ์จาก decision function ตามลำดับ แทนที่จะเป็นการทำนายแบบ hard

ความยืดหยุ่นนี้ทำให้แน่ใจว่าการประเมินของคุณสอดคล้องกับความแตกต่างของปัญหาอย่างสมบูรณ์ ช่วยให้คุณสามารถปรับให้เหมาะสมกับผลลัพธ์เฉพาะที่สำคัญจริงๆ ไม่ว่าจะเป็นการลด false negatives ในการวินิจฉัยทางการแพทย์ หรือการเพิ่ม precision ในการตรวจจับการฉ้อโกง

การประยุกต์ใช้จริง: เมื่อใดควรใช้อะไร

ความแตกต่างระหว่าง metrics และ scoring จะปรากฏชัดเจนที่สุดในเวิร์กโฟลว์ ML ที่ใช้งานจริง นี่คือการแยกย่อย:

Model Selection และ Hyperparameter Tuning

เมื่อคุณกำลังพยายามค้นหาโมเดลที่ดีที่สุดหรือชุด hyperparameter ที่เหมาะสมที่สุด (เช่น โดยใช้ GridSearchCV, RandomizedSearchCV หรือเครื่องมือ ML อัตโนมัติ) คุณมักจะพึ่งพา ฟังก์ชัน scoring ฟังก์ชันเหล่านี้จะส่งคืนค่าเดียวที่สม่ำเสมอซึ่งสามารถทำให้สูงสุด (หรือต่ำสุด) เพื่อนำทางการค้นหากระบวนการ

• ตัวอย่างเช่น ในสถานการณ์การตรวจจับการฉ้อโกง ซึ่งการระบุธุรกรรมที่ฉ้อโกงทั้งหมดมีความสำคัญสูงสุด (recall สูง) คุณอาจตั้งค่า scoring='recall' ใน GridSearchCV ของคุณเพื่อปรับแต่งโมเดลสำหรับ recall โดยเฉพาะ แม้ว่าจะต้องแลกมาด้วย precision ที่ลดลงก็ตาม
• สำหรับการ regression คุณอาจใช้ scoring='neg_mean_absolute_error' เพื่อค้นหา hyperparameter ที่ลด MAE
• หากเป้าหมายทางธุรกิจของคุณคือความสมดุลระหว่าง precision และ recall scoring='f1_macro' หรือ 'f1_weighted' จะเหมาะสมสำหรับปัญหา multi-class

การรายงานประสิทธิภาพและผลกระทบทางธุรกิจ

เมื่อคุณได้เลือกและปรับแต่งโมเดลแล้ว คุณจำเป็นต้องรายงานประสิทธิภาพ ในที่นี้ คุณจะใช้ metrics รายการต่างๆ เพื่อให้มุมมองที่ครอบคลุมเกี่ยวกับพฤติกรรมของโมเดล ค่า scoring ค่าเดียวอาจเพียงพอสำหรับการปรับให้เหมาะสม แต่ก็แทบจะไม่สามารถบอกเรื่องราวทั้งหมดแก่ผู้มีส่วนได้ส่วนเสียได้

• บริษัทอีคอมเมิร์ซระดับโลกอาจจำเป็นต้องรายงานไม่เพียงแค่ accuracy โดยรวมเท่านั้น แต่ยังรวมถึง precision และ recall สำหรับการตรวจจับการ churn ของลูกค้าประเภทต่างๆ (สมัครใจ vs. ไม่สมัครใจ) เพื่อให้แน่ใจว่าการแทรกแซงได้รับการปรับแต่งอย่างมีประสิทธิภาพทั่วทั้งภูมิภาค
• ผู้ให้บริการด้านสุขภาพอาจรายงาน sensitivity (recall) เพื่อแสดงให้เห็นว่ามีการตรวจจับกรณีโรคหายากได้กี่กรณี ควบคู่ไปกับ specificity (true negative rate) เพื่อแสดงให้เห็นว่าผู้ป่วยที่มีสุขภาพดีกี่รายถูกระบุได้อย่างถูกต้อง
• สำหรับโมเดลการพยากรณ์ MAE และ RMSE จะให้แนวคิดเกี่ยวกับข้อผิดพลาดในการทำนายโดยเฉลี่ยในหน่วยสกุลเงิน ซึ่งสามารถตีความได้โดยตรงโดยทีมการเงิน

พิจารณาเสมอว่าผู้มีส่วนได้ส่วนเสียต้องการทราบอะไรจริงๆ บ่อยครั้งที่การรวมกันของ metrics ที่นำเสนออย่างชัดเจน (เช่น ผ่าน classification report หรือด้วยภาพด้วย confusion matrix) จะมีคุณค่ามากกว่าตัวเลขเดียว

การแก้ไขข้อบกพร่องและการปรับปรุงโมเดล

เมื่อโมเดลทำงานได้ไม่ดีอย่างที่คาดไว้ การเจาะลึก metrics ต่างๆ สามารถชี้แจงได้ว่าโมเดลกำลังล้มเหลวที่จุดใด

• Recall ที่ต่ำสำหรับคลาสเฉพาะในปัญหา multi-class (เปิดเผยโดย classification_report) บ่งชี้ว่าโมเดลประสบปัญหาในการระบุอินสแตนซ์ของคลาสนั้น ซึ่งอาจกระตุ้นให้เกิดการตรวจสอบความไม่สมดุลของข้อมูล การสร้างคุณลักษณะ (feature engineering) หรือสถาปัตยกรรมโมเดลที่แตกต่างกัน
• การวิเคราะห์ Confusion Matrix สามารถเปิดเผยประเภทของการจำแนกประเภทผิดที่พบบ่อย มีรูปแบบใน false positives หรือ false negatives หรือไม่?
• สำหรับการ regression การพล็อต residuals (actual - predicted values) สามารถแสดงได้ว่าข้อผิดพลาดเป็นระบบหรือไม่ (เช่น การทำนายค่าสูงอย่างต่อเนื่องต่ำกว่าที่ควรจะเป็น) หรือ heteroscedastic (ข้อผิดพลาดแตกต่างกันไปตามค่าที่ทำนาย)

การตีความผลลัพธ์สำหรับผู้มีส่วนได้ส่วนเสียที่หลากหลาย

การสื่อสารประสิทธิภาพโมเดล ML เป็นทักษะที่สำคัญอย่างยิ่ง โดยเฉพาะอย่างยิ่งในบริบททั่วโลก ผู้มีส่วนได้ส่วนเสียที่แตกต่างกันจะมีความเข้าใจทางเทคนิคในระดับที่แตกต่างกันและความสำคัญที่แตกต่างกัน

• Technical Teams (ML engineers, data scientists): จะเข้าใจ precision, recall, F1, ROC AUC, ฯลฯ และจะชื่นชมความหมายที่ซับซ้อนของแต่ละรายการ
• Business Leaders/Product Managers: มักจะมุ่งเน้นไปที่ metrics ที่แปลเป็นมูลค่าทางธุรกิจโดยตรง: การเพิ่มรายได้, การประหยัดต้นทุน, การรักษาลูกค้า, ประสิทธิภาพการดำเนินงาน สิ่งเหล่านี้อาจได้มาจากหรือสัมพันธ์กับ ML metrics หลัก แต่ถูกนำเสนอในลักษณะที่มุ่งเน้นธุรกิจ ตัวอย่างเช่น แทนที่จะเป็นเพียง "recall สูงสำหรับการฉ้อโกง" อาจเป็น "ประหยัดเงิน X ล้านบาทจากการป้องกันการฉ้อโกง"
• Compliance/Legal Teams: อาจกังวลเกี่ยวกับความเป็นธรรม ความลำเอียง และความสามารถในการอธิบาย (explainability) พวกเขาจะต้องการการรับประกันว่าโมเดลไม่เลือกปฏิบัติต่อกลุ่มใดกลุ่มหนึ่ง และการตัดสินใจของโมเดลสามารถให้เหตุผลได้ Metrics ความเป็นธรรม (จะกล่าวถึงด้านล่าง) จะกลายเป็นสิ่งสำคัญ

ความท้าทายคือการเชื่อมช่องว่างระหว่าง metrics ทางเทคนิคและผลกระทบในโลกแห่งความเป็นจริง โดยใช้ภาษาและการแสดงภาพที่เหมาะสมสำหรับผู้ชมแต่ละกลุ่ม

ข้อพิจารณาขั้นสูงสำหรับโครงการ ML ทั่วโลก

การนำโมเดล ML ไปใช้งานทั่วโลกนำมาซึ่งความซับซ้อนเพิ่มเติม นอกเหนือจากประสิทธิภาพทางเทคนิค การประเมินที่แข็งแกร่งจะต้องขยายไปถึงการพิจารณาทางจริยธรรม การเปลี่ยนแปลงของข้อมูล และการจัดการทรัพยากร

การประเมินความเป็นธรรมและความลำเอียง

โมเดลที่ฝึกด้วยข้อมูลจากภูมิภาคหรือกลุ่มประชากรกลุ่มเดียวอาจทำงานได้ไม่ดีหรือไม่ยุติธรรมต่อกลุ่มอื่น นี่เป็นข้อกังวลที่สำคัญสำหรับการนำไปใช้ทั่วโลก

• Disparate Impact: อัตราข้อผิดพลาดของโมเดลแตกต่างกันอย่างมีนัยสำคัญระหว่างกลุ่มที่ได้รับการคุ้มครอง (เช่น ชาติพันธุ์ เพศ สถานะทางเศรษฐกิจสังคม) หรือไม่?
• Fairness Metrics: นอกเหนือจาก metrics ประสิทธิภาพมาตรฐานแล้ว ให้พิจารณา metrics เช่น Equal Opportunity Difference, Average Odds Difference หรือ Demographic Parity สิ่งเหล่านี้ประเมินว่าโมเดลปฏิบัติต่อกลุ่มต่างๆ อย่างเท่าเทียมกันหรือไม่
• Tools for Fairness: ไลบรารีเช่น Google's What-If Tool หรือ Microsoft's Fairlearn (ใน Python) ช่วยวิเคราะห์และลดความลำเอียง

เป็นสิ่งสำคัญอย่างยิ่งที่จะต้องแบ่งแยก metrics การประเมินของคุณตามกลุ่มประชากรหรือกลุ่มภูมิภาค เพื่อเปิดเผยความลำเอียงที่ซ่อนอยู่ซึ่งอาจไม่ปรากฏใน accuracy หรือ F1-score โดยรวม โมเดลที่มี accuracy 90% ทั่วโลก แต่มี accuracy 50% สำหรับกลุ่มชนกลุ่มน้อยบางกลุ่มนั้นเป็นที่ยอมรับไม่ได้

การตรวจสอบ Data Drift และ Concept Drift

ในสภาพแวดล้อมทั่วโลกที่มีพลวัต รูปแบบข้อมูลอาจเปลี่ยนแปลงไปตามกาลเวลา สิ่งนี้เรียกว่า data drift (การเปลี่ยนแปลงในการกระจายข้อมูลอินพุต) หรือ concept drift (การเปลี่ยนแปลงในความสัมพันธ์ระหว่างตัวแปรอินพุตและเอาต์พุต)

• Continuous Monitoring: ประเมินประสิทธิภาพของโมเดลของคุณอย่างสม่ำเสมอบนข้อมูลใหม่ที่เข้ามา โดยใช้ metrics ที่เลือก
• Alert Systems: ตั้งค่าการแจ้งเตือนหาก metrics ประสิทธิภาพลดลงต่ำกว่าเกณฑ์ที่กำหนด หรือหากการกระจายข้อมูลเปลี่ยนแปลงอย่างมีนัยสำคัญ
• Retraining Strategies: ใช้กลยุทธ์ในการฝึกโมเดลใหม่เป็นระยะๆ หรือเมื่อตรวจพบ drift อย่างมีนัยสำคัญ เพื่อให้แน่ใจว่าโมเดลยังคงมีความเกี่ยวข้องและมีประสิทธิภาพในบริบททั่วโลกที่หลากหลายและเปลี่ยนแปลงไป

ข้อจำกัดด้านทรัพยากรและประสิทธิภาพการคำนวณ

บางภูมิภาคอาจมีทรัพยากรการคำนวณหรือแบนด์วิธที่จำกัด การเลือกโมเดลและกลยุทธ์การประเมินจำเป็นต้องพิจารณาข้อจำกัดในทางปฏิบัติเหล่านี้

• Inference Time: โมเดลสามารถทำการทำนายได้เร็วเพียงใด? สิ่งสำคัญสำหรับการใช้งานแบบเรียลไทม์
• Model Size: โมเดลสามารถนำไปใช้บนอุปกรณ์ edge หรือในสภาพแวดล้อมที่มีหน่วยความจำจำกัดได้หรือไม่?
• Evaluation Cost: แม้ว่าจะสำคัญ แต่ metrics การประเมินบางอย่าง (เช่น Silhouette score สำหรับ clustering) อาจใช้ทรัพยากรในการคำนวณมากสำหรับชุดข้อมูลขนาดใหญ่มาก การสร้างความสมดุลระหว่างความละเอียดและความเป็นไปได้ในทางปฏิบัติ

AI เชิงจริยธรรมและ Explainability (XAI)

นอกเหนือจากตัวเลขแล้ว การทำความเข้าใจว่า ทำไม โมเดลจึงทำการทำนายบางอย่างนั้นมีความสำคัญมากขึ้นเรื่อยๆ โดยเฉพาะอย่างยิ่งในการใช้งานที่มีความสำคัญสูงและในสภาพแวดล้อมด้านกฎระเบียบที่แตกต่างกันทั่วโลก

• Explainability Metrics: แม้จะไม่ใช่ metrics ประสิทธิภาพโดยตรง แต่เทคนิค XAI (เช่น SHAP, LIME) ช่วยอธิบายการตัดสินใจของโมเดล สร้างความไว้วางใจ และช่วยในการตรวจสอบทางจริยธรรม
• Interpretability: การเลือกโมเดลที่ง่ายกว่าและตีความได้ เมื่อประสิทธิภาพเทียบเท่ากับโมเดลกล่องดำที่ซับซ้อนอาจเป็นตัวเลือกที่ชาญฉลาด โดยเฉพาะอย่างยิ่งเมื่อคาดว่าจะมีการตรวจสอบทางกฎหมายหรือจริยธรรม

ตัวอย่างโค้ด Python สำหรับการประเมิน ML

เพื่อให้เห็นภาพแนวคิดเหล่านี้ด้วยตัวอย่างโค้ด Python (Scikit-learn) ที่เป็นแนวคิด ตัวอย่างเหล่านี้สมมติว่าคุณได้ฝึกโมเดลแล้วและมีข้อมูลทดสอบ (X_test, y_test) และการทำนาย (y_pred, y_proba)

            
import numpy as np
from sklearn.model_selection import train_test_split, cross_val_score, cross_validate
from sklearn.linear_model import LogisticRegression, LinearRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import (
    accuracy_score, precision_score, recall_score, f1_score,
    roc_auc_score, log_loss, confusion_matrix, classification_report,
    mean_absolute_error, mean_squared_error, r2_score, make_scorer
)

# --- Sample Data (for demonstration) ---
# For Classification
X_clf = np.random.rand(100, 5) * 10
y_clf = np.random.randint(0, 2, 100) # Binary classification

# Introduce some imbalance for demonstration of metrics' importance
y_clf[80:] = 1 # 20 positive, 80 negative
X_clf_train, X_clf_test, y_clf_train, y_clf_test = train_test_split(
    X_clf, y_clf, test_size=0.3, random_state=42, stratify=y_clf
)

# For Regression
X_reg = np.random.rand(100, 3) * 10
y_reg = 2 * X_reg[:, 0] + 0.5 * X_reg[:, 1] - 3 * X_reg[:, 2] + np.random.randn(100) * 5
X_reg_train, X_reg_test, y_reg_train, y_reg_test = train_test_split(
    X_reg, y_reg, test_size=0.3, random_state=42
)


# --- 1. Classification Model Evaluation ---
print(f"\n--- Classification Model Evaluation ---")
clf_model = LogisticRegression(random_state=42, solver='liblinear')
clf_model.fit(X_clf_train, y_clf_train)
y_clf_pred = clf_model.predict(X_clf_test)
y_clf_proba = clf_model.predict_proba(X_clf_test)[:, 1] # Probability of positive class

print(f"Accuracy: {accuracy_score(y_clf_test, y_clf_pred):.4f}")
print(f"Precision: {precision_score(y_clf_test, y_clf_pred):.4f}")
print(f"Recall: {recall_score(y_clf_test, y_clf_pred):.4f}")
print(f"F1-Score: {f1_score(y_clf_test, y_clf_pred):.4f}")
print(f"ROC AUC: {roc_auc_score(y_clf_test, y_clf_proba):.4f}")
print(f"\nConfusion Matrix:\n{confusion_matrix(y_clf_test, y_clf_pred)}")
print(f"\nClassification Report:\n{classification_report(y_clf_test, y_clf_pred)}")

# Log Loss (requires probabilities)
try:
    print(f"Log Loss: {log_loss(y_clf_test, y_clf_proba):.4f}")
except ValueError:
    print("Log Loss: Probabilities needed for log loss.")


# --- 2. Regression Model Evaluation ---
print(f"\n--- Regression Model Evaluation ---")
reg_model = LinearRegression()
reg_model.fit(X_reg_train, y_reg_train)
y_reg_pred = reg_model.predict(X_reg_test)

print(f"MAE: {mean_absolute_error(y_reg_test, y_reg_pred):.4f}")
print(f"MSE: {mean_squared_error(y_reg_test, y_reg_pred):.4f}")
print(f"RMSE: {np.sqrt(mean_squared_error(y_reg_test, y_reg_pred)):.4f}")
print(f"R2 Score: {r2_score(y_reg_test, y_reg_pred):.4f}")


# --- 3. Using Scikit-learn Scoring Functions (cross_val_score) ---
print(f"\n--- Using Scikit-learn Scoring Functions ---")
# For Classification
clf_model_cv = RandomForestClassifier(random_state=42)
scores_accuracy = cross_val_score(clf_model_cv, X_clf, y_clf, cv=5, scoring='accuracy')
scores_f1 = cross_val_score(clf_model_cv, X_clf, y_clf, cv=5, scoring='f1_macro')
scores_roc_auc = cross_val_score(clf_model_cv, X_clf, y_clf, cv=5, scoring='roc_auc')

print(f"Cross-validated Accuracy (mean): {scores_accuracy.mean():.4f}")
print(f"Cross-validated F1-Macro (mean): {scores_f1.mean():.4f}")
print(f"Cross-validated ROC AUC (mean): {scores_roc_auc.mean():.4f}")

# For Regression
reg_model_cv = LinearRegression()
scores_neg_mse = cross_val_score(reg_model_cv, X_reg, y_reg, cv=5, scoring='neg_mean_squared_error')
scores_r2 = cross_val_score(reg_model_cv, X_reg, y_reg, cv=5, scoring='r2')

# Remember 'neg_mean_squared_error' is negative, so we convert back for interpretation
print(f"Cross-validated MSE (mean): {-scores_neg_mse.mean():.4f}")
print(f"Cross-validated R2 (mean): {scores_r2.mean():.4f}")


# --- 4. Custom Scorer with make_scorer ---
print(f"\n--- Custom Scorer with make_scorer ---")
# Let's say we want to optimize for recall of class 1 (positive class)
custom_recall_scorer = make_scorer(recall_score, pos_label=1, greater_is_better=True)

clf_model_custom_scorer = LogisticRegression(random_state=42, solver='liblinear')
cv_results_custom = cross_val_score(clf_model_custom_scorer, X_clf, y_clf, cv=5, scoring=custom_recall_scorer)
print(f"Cross-validated Custom Recall Score (mean): {cv_results_custom.mean():.4f}")

# Using cross_validate with multiple metrics
scoring_dict = {
    'accuracy': 'accuracy',
    'precision': make_scorer(precision_score, pos_label=1),
    'recall': make_scorer(recall_score, pos_label=1),
    'f1': 'f1_macro',
    'roc_auc': 'roc_auc',
    'neg_mse': 'neg_mean_squared_error' # For regression, just to show multiple types (will not be meaningful here)
}

# Note: This will run classification model with some regression metrics included for demonstration
cv_multiple_scores = cross_validate(
    clf_model_cv, X_clf, y_clf, cv=5, scoring=scoring_dict, return_train_score=False
)

print(f"\nCross-validate with multiple metrics:")
for metric_name, scores in cv_multiple_scores.items():
    if "test" in metric_name: # Focus on test scores
        print(f"  {metric_name}: {scores.mean():.4f}")


            

              
                Copy
              
            
          

ตัวอย่างเหล่านี้แสดงให้เห็นว่า Scikit-learn ของ Python มีเครื่องมือที่จำเป็นในการเปลี่ยนจากการคำนวณ metric พื้นฐานไปสู่การใช้ scoring ที่ซับซ้อนและ cross-validated รวมถึงกลยุทธ์การประเมินแบบกำหนดเอง

แนวปฏิบัติที่ดีที่สุดสำหรับการประเมินที่แข็งแกร่ง

เพื่อให้แน่ใจว่าโมเดล ML ของคุณมีความน่าเชื่อถือ ยุติธรรม และมีผลกระทบในระดับโลก ให้ยึดตามแนวปฏิบัติที่ดีที่สุดเหล่านี้:

• ใช้ Hold-Out Test Set เสมอ: ห้ามประเมินโมเดลของคุณด้วยข้อมูลที่โมเดลเคยเห็นระหว่างการฝึก ชุดทดสอบที่แยกออกมาและไม่เคยเห็นมาก่อนจะให้การประมาณประสิทธิภาพที่ไม่มีอคติ
• ใช้ Cross-Validation เพื่อความน่าเชื่อถือ: สำหรับชุดข้อมูลขนาดเล็กหรือเมื่อต้องการการประมาณประสิทธิภาพที่เสถียรกว่า ให้ใช้ k-fold cross-validation สิ่งนี้ช่วยลดความแปรปรวนของการประมาณประสิทธิภาพ
• พิจารณาวัตถุประสงค์ทางธุรกิจ: เลือก metrics ที่สอดคล้องกับเป้าหมายทางธุรกิจของคุณโดยตรง การเพิ่ม F1-score อาจเป็นเรื่องที่ดีสำหรับรายงานทางเทคนิค แต่การประหยัด X จำนวนเงินด้วยการลด false positives อาจมีความเกี่ยวข้องกับ CEO มากกว่า
• ประเมินด้วย Metrics หลายรายการ: Metric เดียวแทบไม่เคยบอกเรื่องราวทั้งหมด ใช้ชุด metrics ที่เกี่ยวข้อง (เช่น accuracy, precision, recall, F1, ROC AUC สำหรับ classification) เพื่อให้ได้ความเข้าใจที่ครอบคลุมเกี่ยวกับจุดแข็งและจุดอ่อนของโมเดลของคุณ
• แสดงผลลัพธ์ของคุณด้วยภาพ: Confusion matrices, ROC curves, precision-recall curves, และ residual plots นำเสนอข้อมูลเชิงลึกที่มีคุณค่าซึ่งคะแนนตัวเลขเพียงอย่างเดียวไม่สามารถสื่อได้ การแสดงภาพยังยอดเยี่ยมสำหรับการสื่อสารผลลัพธ์ที่ซับซ้อนไปยังผู้มีส่วนได้ส่วนเสียที่ไม่ใช่เชิงเทคนิค
• ตรวจสอบการ Drift: หลังจากการนำไปใช้ ให้ตรวจสอบประสิทธิภาพของโมเดลและลักษณะของข้อมูลที่เข้ามาอย่างต่อเนื่อง Data drift และ concept drift สามารถลดประสิทธิภาพของโมเดลลงได้อย่างเงียบๆ เมื่อเวลาผ่านไป
• จัดการกับ Bias และ Fairness อย่างเชิงรุก: โดยเฉพาะอย่างยิ่งในการนำไปใช้ทั่วโลก ให้แบ่งการประเมินของคุณตามกลุ่มประชากรหรือกลุ่มภูมิภาคที่เกี่ยวข้องเพื่อให้แน่ใจในความเป็นธรรม พยายามอย่างแข็งขันเพื่อระบุและลดความลำเอียง
• บันทึกทุกอย่าง: เก็บบันทึกรายละเอียดเกี่ยวกับวิธีการประเมินของคุณ metrics ที่เลือก และประสิทธิภาพที่สังเกตได้ สิ่งนี้สำคัญสำหรับการทำซ้ำได้ การตรวจสอบ และการปรับปรุงโมเดลในอนาคต

สรุป: การเชี่ยวชาญการประเมินเพื่อผลกระทบระดับโลก

การเดินทางของการสร้างและนำโมเดล Machine Learning ไปใช้งานนั้นซับซ้อน แต่ความสำเร็จขึ้นอยู่กับการประเมินที่แข็งแกร่งและให้ข้อมูลเชิงลึก ด้วยการแยกแยะความแตกต่างระหว่าง metrics (การคำนวณเฉพาะ) และ ฟังก์ชัน scoring (เครื่องมือที่ใช้ในการใช้ metrics เหล่านั้นอย่างเป็นระบบภายใน framework เช่น Scikit-learn) นักวิทยาศาสตร์ข้อมูลสามารถนำทางความซับซ้อนของการประเมินโมเดลด้วยความแม่นยำที่มากขึ้น

สำหรับผู้ชมทั่วโลก ความจำเป็นนั้นเกินกว่าแค่ความถูกต้องทางสถิติ มันครอบคลุมถึงความเป็นธรรม ความสามารถในการปรับตัวให้เข้ากับภูมิทัศน์ข้อมูลที่หลากหลาย ประสิทธิภาพการคำนวณ และความสามารถในการอธิบายที่โปร่งใส ไลบรารี ML ที่ทรงพลังของ Python นำเสนอเครื่องมือที่จำเป็นเพื่อตอบสนองความต้องการเหล่านี้ ช่วยให้ผู้เชี่ยวชาญสามารถสร้าง ประเมิน และนำโซลูชัน AI ที่มีผลกระทบและมีความรับผิดชอบไปใช้ทั่วโลก

การใช้กลยุทธ์การประเมินที่ครอบคลุม แล้วคุณจะไม่เพียงแค่สร้างโมเดลที่ดีขึ้นเท่านั้น แต่ยังส่งเสริมความไว้วางใจที่มากขึ้นและส่งมอบคุณค่าที่ลึกซึ้งยิ่งขึ้นในทุกมุมของโลกที่เชื่อมโยงถึงกันของเรา